COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	\input UNIT.TEX[RDG,DBL]
C00027 00003	\ClassEntry <{ AnyDecomposableObject }  18  {Descendants of this are real world 
C00048 00004	\ClassEntry <{ AnyLogicalOp }  27  {Fill in later.}>
C00081 00005	\StartIndex
C00091 ENDMK
C⊗;
\input UNIT.TEX[RDG,DBL]

\ClassEntry <{ Anything }  1  {The topmost node, in all the hierarchies.}>
\CFact SubClass@AnyAT&U AnyAbstractThing AnyCT&U AnyConcreteThing AnyFocus AnyUnit
>
\CFact Direct Examples@AnyClassOfObjects>
\SlotsFor {thing}

\SlotEntry <{Isa} {FSet (UnitType (*P AnyClassOfObjects))} {This primitive slot 
is the fundamental hierarchical link in this system, specifying those classes to
 which this unit belongs. Note that its format is SET - hence this system can handle
 a DAG structure; better for our purposes than a tree.}>
\SFact Inverse@UnitExamples>

\SlotEntry <{Characteristics} {FSet NonNILType} {This lists some essential characteristics
 of this unit. (Not currently in use.)}>
\SFact HighLevelDefn@(Unioning FunctionCharacter FormatCharacter)>

\SlotEntry <{Descr} {FSingleton NonNILType} {This describes this unit. (It is used
 to generate this document.)}>

\SlotEntry <{AllIsas} {FSet UnitType} {This specifies each class to which this unit
 belongs. (It includes each \Slot (SuperClass) \ of this unit's \Slot (Isa) \ slot.
)}>
\SFact Inverse@AllExamples>
\SFact HighLevelDefn@(Composition SuperClass* Isa)>

\SlotEntry <{AllGenls} {FSet UnitType} {This points to a list of those units which
 are somehow more general than this unit.}>
\SFact Inverse@AllSpecs>
\SFact HighLevelDefn@(Unioning Prototypes (OneOf SuperClass* SuperTypEx* SuperSlot* GenlAct*))>

\SlotEntry <{AllSpecs} {FSet UnitType} {This lists every unit which is somehow more
 precise than this unit.}>
\SFact Inverse@AllGenls>
\SFact HighLevelDefn@(Unioning AllTypicalExampleOfs (OneOf SubClass* SubTypEx* SubSlot* SpecAct*))>

\SlotEntry <{Prototypes} {FSet (UnitType (*P AnyArchetype))} {This points to each
 typical example of this unit, not necessarily in order of increasing generality.
}>
\SFact Inverse@AllTypicalExampleOfs>
\SFact HighLevelDefn@(Composition TypicalExample AllIsas)>

\SlotEntry <{Specializations} {FSet UnitType} {This points to each unit which ``specializes''
 this unit.}>
\SFact Inverse@Generalizations>
\SFact HighLevelDefn@(OneOf SubSlot SpecAct SubTypEx SubDT SubClass)>

\SlotEntry <{OrderedPrototypes} {FOrderedSet UnitType} {Enumerates the prototypes
 of this unit in order of increasing generality (i.e. \Unit (TypicalDog) \ would
 precede \Unit (TypicalAnimal) .)}>
\SFact HighLevelDefn@(PutInOrder Prototypes SuperTypEx* NIL MembForOrdPro)>

\ClassEntry <{ AnyAT&U }  2  {This is a HACK - to deal with the units in this system,
 which represent both some abstract object (NOT in the world,) and themselves...
}>
\CFact SuperClass@Anything>
\CFact SubClass@AnyIntensionalObject AnyPartialSpec>

\ctrline{\it The slots appropriate for all ``AT&U''s are those defined for each of: (
\Unit (AnyUnit)\  \Unit (AnyAbstractThing)\ ).}

\ClassEntry <{ AnyIntensionalObject }  3  {Descendants of this unit describe some
 entity in the world intensionally -- as opposed to directly referring to in.}>
\CFact SuperClass@AnyAT&U AnyCT&U>
\CFact SubClass@AnyArchetype AnyDescriptor AnyUnitForSlot AnyVariable>

\ClassEntry <{ AnyArchetype }  4  {Every typical example of some class is an archetype,
 and descends from this unit.}>
\CFact SuperClass@AnyIntensionalObject>
\hmode{\qquad There are currently 123 examples.}\par
\SlotsFor {Archetype}

\SlotEntry <{NewPossibleSlots} {FSet SlotType} {This lists the names of slots which
 are meaningful for every ``instance'' of this typical example. Furthermore, this
 is the highest place where this slot is meaningful (hence the ``{\sl new}ness''
 of the name.)}>
\SFact Inverse@MakesSenseFor>
\SFact HighLevelDefn@(Composition (Soften NewPossibleSlots) MyComposeOf)>

\SlotEntry <{TypicalExampleOf} {FSingleton (UnitType (*P AnyClassOfObjects))} {Refers
 back, from the typical example unit, to the class of elements it typifies.}>
\SFact Inverse@TypicalExample>

\SlotEntry <{SuperTypEx} {FSet UnitType} {This denotes the relation connecting \Unit
 (TypicalDog) \ to \Unit (TypicalAnimal) \ -- i.e. a superset relation holds between
 the elements each (respectively) typifies.}>
\SFact Inverse@SubTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass TypicalExampleOf)>

\SlotEntry <{SubTypEx} {FSet UnitType} {See \Slot (SuperTypEx) .}>
\SFact Inverse@SuperTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SubClass TypicalExampleOf)>

\SlotEntry <{PossibleSlots} {FSet UnitType} {This is obsolete - and will soon be
 deleted.}>
\SFact HighLevelDefn@(Composition NewPossibleSlots SuperTypEx*)>

\SlotEntry <{SuperTypEx*} {FSet UnitType} {This is the transitive closure of \Slot
 (SuperTypEx) .}>
\SFact Inverse@SubTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass* TypicalExampleOf)>

\SlotEntry <{SubTypEx*} {FSet (UnitType (*P AnyArchetype))} {This is the transitive
 closure of \Slot (SubTypEx) .}>
\SFact Inverse@SuperTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SubClass* TypicalExampleOf)>

\ClassEntry <{ AnyDescriptor }  5  {This will eventually hold descriptors -- a whole
 class of entities which will have to be defined...}>
\CFact SuperClass@AnyIntensionalObject>

\ClassEntry <{ AnyUnitForSlot }  6  {At times, there is more than just one ``morsel''
 of information needed to describe the value of some unit's slot. RLL then devotes
 an entire unit to hold this information. Such units descend from this \Unit (AnyUnitForSlot.
)}>
\CFact SuperClass@AnyIntensionalObject>
\SlotsFor {UnitForSlot}

\SlotEntry <{*vaLue*} {FSingleton NonNILType} {When a unit is allocated to store
 facts about the value of a slot, the actual value of that slot, if any, is kept
 in the \Slot (*vaLue*) \ slot of that sub unit.}>
\SFact HighLevelDefn@(Application (Composition Defn LivesInSlot) LivesInUnit)>

\ClassEntry <{ AnyVariable }  7  {This class contains the universally or existentially
 bound variables. Note that this is a META description of said units.}>
\CFact SuperClass@AnyIntensionalObject>

\ClassEntry <{ AnyPartialSpec }  8  {This class includes objects which are only 
partial specified. This is essential to deal with MOLGEN UNITs package notion of
 SPEC inheritance -- in which some object is specified more and more completely.
}>
\CFact SuperClass@AnyAT&U>
\CFact SubClass@AnyGenericEvent>
\SlotsFor {PartialSpec}

\SlotEntry <{MyRefineSlots} {FSet SlotType} {The value of \UnitSlot (U:MyRefineSlots
) \ is a list of those slots on the unit \Unit (U) \ which are used to specify facts
 which are not definitional.}>

\ClassEntry <{ AnyAbstractThing }  9  {Instances refer to intangible objects; as
 opposed to concrete things (such as real world people or units) .}>
\CFact SuperClass@Anything>

\ClassEntry <{ AnyCT&U }  10  {This is a HACK - to deal with the units in this system,
 which represent both some object in the world, and themselves...}>
\CFact SuperClass@Anything>
\CFact SubClass@AnyCharacteristic AnyClassOfObjects AnyDecomposableObject AnyEvent
 AnyInheritance AnyIntensionalObject AnyOverhead AnyProcess AnyUnit AnyUser>

\ctrline{\it The slots appropriate for all ``CT&U''s are those defined for each of: (
\Unit (AnyUnit)\  \Unit (AnyConcreteThing)\ ).}

\ClassEntry <{ AnyCharacteristic }  11  {This fathers units which describe characteristics
 of some entity -- as opposed to something which actually exists in and of itself.
}>
\CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyDatatype AnyFormat>

\ClassEntry <{ AnyDatatype }  12  {Every datatype (used for building up type specifications,
) descends from this.}>
\CFact SuperClass@AnyCharacteristic>
\CFact Direct Examples@KBType NonNILType NumberType BooleanType UnrestrictedType
 FunctionType SlotType IntegerType UnitType StringType>
\SlotsFor {Datatype}

\SlotEntry <{EqualDTSpec} {FSet (FListN (UnitType (*P AnyDatatype)) UnrestrictedType
)} {This helps relate one datatype to another -- by defining a set of equivalent
 datatype-datarange pairs.}>

\SlotEntry <{VerifyType} {FSingleton FunctionType} {\UnitSlot (DT:VerifyType) is
 a predicate, returning non{\LispFn (NIL) } for all elements which qualify in this
 datatype.}>

\SlotEntry <{GenerateAll} {FSingleton FunctionType} {\UnitSlot (DT:GenerateAll) 
returns a list of all members of the datatype, \Unit (DT) .}>

\SlotEntry <{SuperDT} {FSet (UnitType (*P AnyDatatype))} {This points to the list
 of more general datatypes -- i.e. those which contain a superset of this datatype's
 members.}>
\SFact Inverse@SubDT>

\SlotEntry <{SubDT} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (DT:SubDt) points
 to Datatypes which accept a subset of those accepts by the datatype \Unit (DT) 
.}>
\SFact Inverse@SuperDT>

\SlotEntry <{RangeInterpreter} {FSingleton FunctionType} {\UnitSlot (DT:RangeInterpreter
) is a function which helps parse the value of \UnitSlot (S:DataRange) , which is
 used to determine the appropriate values to fill \UnitSlot (U:S) .}>

\SlotEntry <{IsTypeOf} {FSet SlotType} {Points from a datatype to those units representing
 functions whose range is composed of this datatype.}>
\SFact Inverse@Datatype>

\SlotEntry <{SuperDT*} {FSet UnitType} {A list of a unit's SuperDT, THEIR SuperDT,
 etc.}>
\SFact Inverse@SubDT*>
\SFact HighLevelDefn@(Starring SuperDT)>

\SlotEntry <{SubDT*} {FSet (UnitType (*P AnyDatatype))} {Transitive closure of \Unit
 (SubDT) .}>
\SFact Inverse@SuperDT*>
\SFact HighLevelDefn@(Starring SubDT)>

\ClassEntry <{ AnyFormat }  13  {From this descends the units which each serve to
 describe some format; which can be used in a type description.}>
\CFact SuperClass@AnyCharacteristic>
\CFact SubClass@AnySlotFormat AnyValueFormat>
\SlotsFor {Format}

\SlotEntry <{FnForAdding} {FSingleton FunctionType} {One should add a new entry 
to a Ordered LIST in a different manner than one uses to add a value to an Unordered
 SET. (In the first case, multiple occurances of an element are acceptable; which
 is NOT true in the second case.) This information is contained in the function 
stored in \UnitSlot (F:FnForAdding) . Note it is used by the various {\LispFn (Add
) }ing functions -- such as the one employed to add a new entry to the existing 
value of a unit's slot.}>

\SlotEntry <{FnForDeleting} {FSingleton FunctionType} {There are different ways 
of deleting an element from a list, versus from a set. As with \Slot (FnForAdding
) , this information is stored in \UnitSlot (F:FnForDeleting) , where \Unit (F) 
\ is the name of a format.}>

\SlotEntry <{FormatCharacter} {FSet NonNILType} {This holds a list of specifications
 for some format. It is not currently used for anything but show.}>

\SlotEntry <{FnForGetting} {FSingleton FunctionType} {This is used to determine 
the value of a special slot value, to be returned when \LispFn (GetValue) \ requests
 its value.}>

\SlotEntry <{FnForPutting} {FSingleton FunctionType} {This indicates how to put 
a value. It is basically used for indirect pointers.}>

\SlotEntry <{FnForKilling} {FSingleton FunctionType} {To handle indirect pointers
 using the \LispFn (*Do*) \ special slot values, one needs assistance to describe
 how to perform various manipulations -- such as deleting a full slot's value. This
 information is kept in \UnitSlot (VF:FnForKilling) , where \Unit (VF) \ is a value
 format.}>

\SlotEntry <{FnForVerifyingAll} {FSingleton FunctionType} {This is used, in conjunction
 with the various verifying functions associated with each datatype, to build the
 function stored in the \Slot (VerifyValue) \ slot of each slot. It indicates how
 to verify that a full entry is correct, given, (among other arguments,) the predicate
 to apply to each entry individually.}>

\SlotEntry <{FnForVerifyingElement} {FSingleton FunctionType} {This is used to verify
 that a single element is correct. (Perhaps this isn't used anymore -- I must look
 into this.)}>

\ClassEntry <{ AnySlotFormat }  14  {Descendants are used in type specifications,
 for processes (which include functions and slots) .}>
\CFact SuperClass@AnyFormat>
\CFact Direct Examples@FSingleton FList FSet FOrderedSet FBag FListN>

\ClassEntry <{ AnyValueFormat }  15  {Descendants are used in a \LispFn (*Do*) \
 special slot value format. This has applications as indirect pointers, as well 
as to put epistemological marks on some value.}>
\CFact SuperClass@AnyFormat>
\CFact SubClass@AnyIndirectPtrFormat>
\CFact Direct Examples@FOneOf FExecute>

\ClassEntry <{ AnyIndirectPtrFormat }  16  {These are used to deal with subunits,
 and other places where much data is stored at another location -- other than \UnitSlot
 (U:S) .}>
\CFact SuperClass@AnyValueFormat>
\CFact Direct Examples@FSeeUnit FSeeSlot FSeeU&S>

\ClassEntry <{ AnyClassOfObjects }  17  {Every member of this class is itself a 
set.}>
\CFact SuperClass@AnyCT&U>
\hmode{\qquad There are currently 47 examples.}\par
\SlotsFor {ClassOfObjects}

\SlotEntry <{TypicalExample} {FSingleton (UnitType (*P AnyArchetype))} {This points
 from a class to an abstract entity which holds default information about members
 of this class.}>
\SFact Inverse@TypicalExampleOf>

\SlotEntry <{DomainOf} {FSet (UnitType (*P AnyFunction))} {If a function takes one
 or more elements of this class, as arguments, that function is stored on the \LispFn
 (DomainOf) \ slot of the unit representing that class.}>
\SFact Inverse@Domain>

\SlotEntry <{RangeOf} {FSet (UnitType (*P AnyFunction))} {If a function maps into
 this class (or a space having this class as one dimension,) that function is stored
 on the \LispFn (RangeOf) \ slot of the unit representing that class.}>
\SFact Inverse@Range>

\SlotEntry <{IntensionalExamples} {FSet UnitType} {These examples are all intentional
 objects -- that is, they are only defined intentionally.}>

\SlotEntry <{StdExamples} {FSet UnitType} {This slot basically represents the vanilla
 ``\EPSILON'' relationship, between an extensional object, and a represented set.
}>

\SlotEntry <{SuperClass} {FSet (UnitType (*P AnyClassOfObjects))} {This points from
 a class, C, to each superset of C, D\Sub (i) . That is, x \EPSILON C => x \EPSILON
 D\Sub (i) , for all elements x, and all sets, D\Sub (i) .}>
\SFact Inverse@SubClass>

\SlotEntry <{SubClass} {FSet UnitType} {This points from a class, C, to each subset
 of C.}>
\SFact Inverse@SuperClass>

\SlotEntry <{UnitExamples} {FSet UnitType} {This points from a class to each member
 of that class. (Both constant and variable.)}>
\SFact Inverse@Isa>
\SFact HighLevelDefn@(Unioning IntensionalExamples StdExamples)>

\SlotEntry <{TotalSoFar} {FSingleton IntegerType} {Fill in later.}>

\SlotEntry <{SuperClass*} {FSet UnitType} {A list of a unit's SuperClass, THEIR 
SuperClass, etc.}>
\SFact Inverse@SubClass*>
\SFact HighLevelDefn@(Starring SuperClass)>

\SlotEntry <{SubClass*} {FSet UnitType} {A list of a unit's SubClass, THEIR SubClass,
 etc.}>
\SFact Inverse@SuperClass*>
\SFact HighLevelDefn@(Starring SubClass)>

\SlotEntry <{AllExamples} {FSet UnitType} {This points from a class to a list of
 members of this class. (\Slot (UnitExamples) \ only pointed to elements immediately
 a member of some set --- this will follow their \Slot (SuperClass) \ links as well,
 to more accurately represent an ``\EPSILON'' relation.)}>
\SFact Inverse@AllIsas>
\SFact HighLevelDefn@(Composition UnitExamples SubClass*)>

\SlotEntry <{GenlsModels} {FSet (UnitType (*P AnyArchetype))} {This is used for 
several of the inheritances. The prototypes of every example of some class include
 that class's \Slot (GenlsModels) .}>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass*)>

\ClassEntry <{ AnyDecomposableObject }  18  {Descendants of this are real world 
entities which consist of several subparts; and which are little more than the union
 of such pieces.}>
\CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyActionSequence>
\SlotsFor {DecomposableObject}

\SlotEntry <{ComposedOf} {FSet NonNILType} {This points to a list of the parts associated
 with this entity.}>

\ClassEntry <{ AnyActionSequence }  19  {Any compound action, composed a sequence
 of subactions, descends from this unit.}>
\CFact SuperClass@AnyAction AnyDecomposableObject>
\SlotsFor {ActionSequence}

\SlotEntry <{SubActions} {FList NonNILType} {Each action may be broken into a series
 of substeps -- each of which is a ``subaction''.}>

\ClassEntry <{ AnyInheritance }  20  {All modes of inheritance will descend from
 here. Associated with each instance of an inheritance is a means for creating new
 units, and constraints on properties these units may acquire. (and maybe other 
things...)}>
\CFact SuperClass@AnyCT&U>
\CFact Direct Examples@IExamples ISubClass ITypEx>
\SlotsFor {Inheritance}

\SlotEntry <{UseToGetSlots} {FSingleton NonNILType} {This points to a high level
 definition of a function which is takes the parent units, and returns a list of
 units whose \Slot (NewPossibleSlots) \ slot together hold the slots which should
 be initialized in this new offspring.}>

\SlotEntry <{GetPossibleSlotsFn} {FSingleton SlotType} {This points a unit which
 represents a function, which takes the units found using the \Slot (UseToGetSlots
) \ function mentioned above, and returns a list of values with which to initialize
 a new unit. Each entry in this ordered list is a triple, consisting of the name
 of the slot, followed by the location of the relevant initializing function, and
 the typical example in which this slot was found.}>
\SFact Inverse@UsedByInheritance>

\ClassEntry <{ AnyOverhead }  21  {Miscellaneous information needed by CORLL, etc.,
 is stored on units which descend from here.}>
\CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyStatus>

\ClassEntry <{ AnyStatus }  22  {This will father all *.STATUS units}>
\CFact SuperClass@AnyOverhead>
\CFact Direct Examples@RLL.STATUS>
\SlotsFor {Status}

\SlotEntry <{KBsVARS} {FSingleton NonNILType} {This names a variable, whose value
 lists the variables associated with this Knowledge Base.}>

\SlotEntry <{KBsConnectedTo} {FSet (UnitType (*P AnyStatus))} {The value of { \UnitSlot
 (<kb>.STATUS:KBsConnectedTo) \ } is a list of other status units, which were resident
 in core the last time this Knowledge Base, { <kb>, } was used. It is reset whenever
 a new Knowledge Base is read in, or whenever one is disconnected or reconnected.
}>
\SFact Inverse@KBsConnectedTo>

\SlotEntry <{OpenDate} {FSingleton StringType} {This holds the time stamp when this
 Knowledge Base was openned -- i.e. the start of this session.}>

\SlotEntry <{NetworkStatus} {FSingleton NonNILType} {This stores the last person
 to use this Knowledge Base, and when that last use was.}>

\SlotEntry <{WhenOpeningNetwork} {FSingleton UnrestrictedType} {This points to a
 list of functions which CORLL calls when openning this Knowledge Base. Each takes
 two arguments -- the first is the name of this KB, and the second is passed from
 \LispFn (WhenOpenningNetworks) , serves to suppress questions and messages.}>

\SlotEntry <{LoadFiles} {FSet NonNILType} {This lists the files which CORLL will
 read in whenever it opens this network. It will also ask if it should \LispFn (
MAKEFILE) \ these when this Knowledge Base is closed.}>

\SlotEntry <{KBsFNS} {FSingleton NonNILType} {This points to a variable whose value
 lists the functions relevant to this Knowledge Base.}>

\SlotEntry <{WhenWritingNetwork} {FSingleton NonNILType} {This points to a list 
of functions which CORLL calls when writing out this Knowledge Base. Each takes 
two arguments -- the first is the name of this KB, and the second is passed from
 \LispFn (WhenWritingNetworks) , serves to suppress questions and messages.}>

\SlotEntry <{Networks} {FSet KBType} {Each Knowledge Base may depend, hierarchically,
 on the presence of other knowledge bases, in core. The KBs {\Unit (<kb>) } requires
 are listed in {\UnitSlot (<kb>.STATUS:Networks) }.}>

\SlotEntry <{KBsUnitIndex} {FSingleton NonNILType} {This points to the unit which
 holds the unit index CORLL uses for this Knowledge Base.}>

\SlotEntry <{KBsFreeBlockIndex} {FSingleton NonNILType} {This points to the unit
 which holds the free block index CORLL uses for this Knowledge Base.}>

\SlotEntry <{DependentNetworks} {FSet KBType} {This lists the Knowledge Bases which
 rely on the presence of this Knowledge Base to operate.}>

\ClassEntry <{ AnyProcess }  23  {Every action which takes place, in LISP, is a 
\LispFn (Process) . This corresponds to each function in LISP.}>
\CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyAction AnyFunction AnyUnitListProcess>
\SlotsFor {Process}

\SlotEntry <{CVUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:CVUsedBy
) \ means \Unit (x) s cached-value should be updated whenever \Unit (y) s cached-value
 changes.}>
\SFact Inverse@IUseCVOf>

\SlotEntry <{DefnUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:DefnUsedBy
) \ means \Unit (x) s defn, and maybe its previously stored values, should be updated
 whenever \Unit (y) s defn changes}>
\SFact Inverse@IUseDefnOf>

\SlotEntry <{IUseCVOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot (
x:IUseCVOf) \ means if the \Slot (y) \ stored value of some \Unit (z) \ should change,
 some \Unit (x) \ value may change as well.}>
\SFact Inverse@CVUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllCVs HighLevelDefn)>

\SlotEntry <{IUseDefnOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot
 (x:IUseDefnOf) \ means \Unit (x) s defn, and maybe its previously stored values,
 should be updated whenever \Unit (y) s defn changes}>
\SFact Inverse@DefnUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllFNS HighLevelDefn)>

\SlotEntry <{LispFn} {FSingleton FunctionType} {The actual compiled code LISP will
 run, to process a process, is stored here.}>
\SFact HighLevelDefn@(OneOf LispFnForSlot LispFnForStoredFn)>

\SlotEntry <{HowToProcess} {FSingleton FunctionType} {This will soon be deleted,
 in favor of LispFn.}>

\SlotEntry <{WhatToProcess} {FSet UnrestrictedType} {Fill in later.}>
\SFact HighLevelDefn@(OneOf TaskList RuleList)>

\SlotEntry <{VerifyArgs} {FSingleton FunctionType} {The value of \UnitSlot (F:VerifyArgs
) is a function which is true if its argument is acceptable as input to the function
 represented by \Unit (F) .}>

\ClassEntry <{ AnyAction }  24  {This includes any activity carried out in the real
 world by physical objects.}>
\CFact SuperClass@AnyProcess>
\CFact SubClass@AnyActionSequence>
\CFact Direct Examples@DescribeUnit>
\SlotsFor {Action}

\SlotEntry <{SpecAct} {FSet UnitType} {This points to ``refinements'' of this action
 -- i.e. activities which are more precisely specified.}>
\SFact Inverse@GenlAct>

\SlotEntry <{GenlAct} {FSet UnitType} {This points to actions which are more general
 (i.e. at a higher level of abstraction) than the action encoded by this unit. E.g.
 \Unit (Locomotions) \EPSILON \UnitSlot (Walking : GenlAct) .}>
\SFact Inverse@SpecAct>

\SlotEntry <{SpecAct*} {FSet UnitType} {A list of a unit's SpecAct, THEIR SpecAct,
 etc.}>
\SFact Inverse@GenlAct*>
\SFact HighLevelDefn@(Starring SpecAct)>

\SlotEntry <{GenlAct*} {FSet UnitType} {A list of a unit's GenlAct, THEIR GenlAct,
 etc.}>
\SFact Inverse@SpecAct*>
\SFact HighLevelDefn@(Starring GenlAct)>

\ClassEntry <{ AnyFunction }  25  {Functions are distinquished from processes in
 that the primary purpose of a function is to return a value. Note a process may
 be run, in effect, for some side effect. (Yes, this is NOT pure LISP.)}>
\CFact SuperClass@AnyProcess>
\CFact SubClass@AnyFunctional AnyPredicate AnyStorableFn AnyUnitListFn>
\SlotsFor {Function}

\SlotEntry <{SlotsUsedInBuilding} {FSet SlotType} {Lists the slots which this one
 contributes to defining.}>
\SFact Inverse@AllSBF>

\SlotEntry <{HighLevelDefn} {FSingleton NonNILType} {Here is stored a High Level
 Specification of the code to be run. This can be ``parsed'' into a piece of LISP
 code, which LISP can execute. Ideally, the information here should be sufficient
 to fully specify a function.}>

\SlotEntry <{DataRange} {FSingleton NonNILType} {The value of \UnitSlot (F:DataRange
) \ is used by the range interpreter associated with \Unit (D) , the \Slot (Datatype
) of the function \Unit (S) , to generate a function capable of deciding whether
 a value is acceptable or not.}>

\SlotEntry <{Datatype} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (S:Datatype
) \ points to the list of units in the range of the function, \Unit (F) .}>
\SFact Inverse@IsTypeOf>

\SlotEntry <{Format} {FSingleton (UnitType (*P AnyFormat))} {This stores the format
 of the result this function is expected to return.}>

\SlotEntry <{FunctionCharacter} {FSet NonNILType} {This holds facts which serve 
to describe this function. It is not currently used.}>

\SlotEntry <{Defn} {FSingleton FunctionType} {This function must take in a slot 
name \Unit (s) \ and return a function capable of reading/computing \Unit (s) \ 
in general. Ultimately, \UnitSlot (Defn:Defn) \ should have a self-compiling call
 placed in each value it returns.}>
\SFact HighLevelDefn@(Apply*ingFn CAR FunctionSpec)>

\SlotEntry <{Definition} {FSingleton NonNILType} {This is not currently used; and
 may be meaningless.}>

\SlotEntry <{Domain} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
 each of which represent a class in the domain of this function.}>
\SFact Inverse@DomainOf>

\SlotEntry <{Range} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
 which each represent a class in the range of this function.}>
\SFact Inverse@RangeOf>

\SlotEntry <{IsBuiltFrom} {NotAFormat NotARange} {Appears in unit X, for a type 
of slot, and lists the old things out of which X has been defined}>
\SFact HighLevelDefn@(Apply*ingFn AllButHead HighLevelDefn)>

\SlotEntry <{UnitsBuiltFrom} {NotAFormat NonNILType} {This is going away soon.}>
\SFact Inverse@UsedInBuilding>
\SFact HighLevelDefn@(Subsetting IsBuiltFrom Unitp)>

\SlotEntry <{UsingFunctionals} {NotAFormat NotARange} {Appears as a slot in unit
 X, and tells how X was defined out of other slots}>
\SFact Inverse@CombinerFor>
\SFact HighLevelDefn@(Subsetting UsingFunctions (MemberOf AllIsas AnyFunctional))>

\SlotEntry <{SlotsBuiltFrom} {NotAFormat NonNILType} {Fill in later.}>
\SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Subsetting UnitsBuiltFrom (MemberOf AllIsas AnySlot))>

\SlotEntry <{UsingFunctions} {NotAFormat NotARange} {Appears as a slot in unit X,
 and tells how X was defined out of other slots}>
\SFact HighLevelDefn@(Apply*ingFn OnlyHead HighLevelDefn)>

\SlotEntry <{PreConditions} {FSet NonNILType} {Fill in later.}>

\SlotEntry <{DomainType} {FList NonNILType} {This holds a type specification indicating
 the domain over which this function is defined.}>

\SlotEntry <{RangeType} {FList NonNILType} {This holds a type specificiation, indicating
 the range into which this function will map.}>

\ClassEntry <{ AnyFunctional }  26  {Each descendant unit represents a function 
whose range is a space of functions.}>
\CFact SuperClass@AnyFunction>
\CFact SubClass@AnyLogicalOp AnySlotCombiner>
\CFact Direct Examples@ApplyToEach Apply*ingFn ApplyingFn MemberOf>
\SlotsFor {Functional}

\SlotEntry <{GetCVsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetCVsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
 of storable functions on whose cached values this HLDefn depends. (\Unit (SC) \
 is the \LispFn (CAR) \ of that HLDefn.) This computed function can then be stored
 on the function \Unit (S) , which will usually be a slot.}>

\SlotEntry <{GetFnsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetFnsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
 of functions on whose definition this HLDefn depends. This can then be stored on
 the function \Unit (S) , which will usually be a slot.}>

\SlotEntry <{CombinerFor} {FSet (UnitType (*P AnyFunction))} {This slot appears 
in a unit X for a type of functions, and lists those slots which are defined out
 of old ones by using X}>
\SFact Inverse@UsingFunctionals>

\SlotEntry <{ToParseParts} {FSingleton FunctionType} {This value is used by each
 Slot Combiner to parse its list of arguments.}>

\ClassEntry <{ AnyLogicalOp }  27  {Fill in later.}>
\CFact SuperClass@AnyFunctional>
\CFact Direct Examples@L-Optional L-NOT L-OR>

\ClassEntry <{ AnySlotCombiner }  28  {An operator which takes some old slots and
 defines a new one out of them.}>
\CFact SuperClass@AnySlotListFn AnyFunctional>
\CFact Direct Examples@DoneIndirectly Listing PutInOrder Soften OneOf Plussing OrderedUnioning
 Unioning OrderedComposition OrderedStarring Composition Application Starring FirstOk
 Intersecting CommonXProd Subsetting>
\SlotsFor {SlotCombiner}

\SlotEntry <{FnForInverting} {FSingleton FunctionType} {To find the inverse of a
 slot, one can examine the high level definition of that slot, and attempt to invert
 that. The \Slot (FnForInverting) \ slot of a slot combiner, \Unit (SC) , is a function
 which takes as an argument a high level definition, and returns the high level 
definition of a slot which computes the inverse functions from the original slot.
}>

\SlotEntry <{FnForUpdating} {FSingleton FunctionType} {When a new value is placed
 in a slot, several other slots in the Knowledge Base must be updated. Such updates
 are performed by executing the code stored in the \Slot (KBUpates) \ slot of this
 slot. The \Slot (FnForUpdating) \ slot of a slot combiner is used to compute this
 \Slot (KBUpdates) . It takes a high level definition as its argument, with this
 particular slot combiner as principle slot combiner, and returns, essentially, 
the value for the \Slot (KBUpdates) \ slot for this slot (defined by that high level
 definition) .}>

\SlotEntry <{FnForCaching} {FSingleton FunctionType} {After the value of a slot 
has been computed (using the slot's definition,) RLL then considers storing that
 value away. Each slot combiner suggests an appropriate algorithm for deciding whether
 to store such values, and where. That procedure is encoded in the \Slot (FnForCaching
) \ slot of the slot combiner. (This function takes a high level definition as an
 argument, and returns a function to fill the \Slot (ToCache) \ slot of a slot.)
}>

\ClassEntry <{ AnyPredicate }  29  {These functions return a value which is used
 as a Boolean -- i.e. they serve to intensionally define a set.}>
\CFact SuperClass@AnyFunction>

\ClassEntry <{ AnyStorableFn }  30  {This class contains those functions whose value,
 on some input, might be stored, (or cached,) away. Note at least one of the arguments
 must be a unit.}>
\CFact SuperClass@AnyFunction>
\CFact SubClass@AnyUnitListFn>
\SlotsFor {StorableFn}

\SlotEntry <{ToCache} {FSingleton FunctionType} {The function stored here is called
 after a value has been calculated. This function then decides whether to store 
this value for future use, and if so, where.}>

\SlotEntry <{StoredAList} {FSet (FSet UnrestrictedType)} {This stores some i/o pairs
 for this function, as an association list.}>

\SlotEntry <{LispFnForStoredFn} {FSingleton FunctionType} {This function, used as
 the value for \LispFn (LispFn) , does the following: First try to find the value
 by looking it up. If that fails, compute it; and consider caching the results. 
Of course, then return the computed (or retrieved) value.}>

\SlotEntry <{ToInvalidate} {FSingleton FunctionType} {The function stored here is
 used when some cached value is to be discarded.}>

\SlotEntry <{ToConfirmValue} {FSingleton FunctionType} {When retrieving a potential
 value for some input data, the predicate stored on this function's \Slot (ToConfirmValue
) \ slot is used to see if this value is valid.}>

\SlotEntry <{ToLookUp} {FSingleton FunctionType} {The value of this slot is a function,
 which attempts to retrieve a cached value of this function.}>

\ClassEntry <{ AnyUnitListFn }  31  {Here will be any mapping which takes, as an
 argument, one or more units}>
\CFact SuperClass@AnyStorableFn AnyFunction>
\CFact SubClass@AnySlotGetter AnySlotListFn AnyUnitFunction>

\ClassEntry <{ AnySlotGetter }  32  {Examples are the units used to get the list
 of slot types which new units, created using some inheritance mechanism, should
 have.}>
\CFact SuperClass@AnyUnitListFn>
\CFact Direct Examples@PossibleSlotsOfISubClass PossibleSlotsOfITypEx PossibleSlotsOfIExamples
>

\ClassEntry <{ AnySlotListFn }  33  {Descendants are functions which takes one or
 more slots as arguments.}>
\CFact SuperClass@AnyUnitListFn>
\CFact SubClass@AnySlotCombiner>

\ClassEntry <{ AnyUnitFunction }  34  {Descendants each represent a mapping which
 takes, as an argument, a unit.}>
\CFact SuperClass@AnyUnitListFn>
\CFact SubClass@Any$SELF$Slot AnySlot>
\CFact Direct Examples@FunctionSpec MyKB>
\SlotsFor {UnitFunction}

\SlotEntry <{HandDoneSBF} {FSet SlotType} {This is used to enter the names of slots
 (or, in general, functions,) which current slot was built from.}>

\SlotEntry <{UsingSlotCombiners} {NotAFormat NotARange} {Appears as a slot in unit
 X, and tells how X was defined out of other slots}>
\SFact HighLevelDefn@(Subsetting UsingFunctionals (MemberOf AllIsas AnySlotCombiner))>

\SlotEntry <{AfterGetValue} {FSingleton FunctionType} {The value of \UnitSlot (S:AfterGetValue
) is a function which is applied to a unit \Unit (U) \ the \Slot (S) and the value
 \UnitSlot (U:S) , after determining this value. Any final test to be made, can 
be done here.}>

\SlotEntry <{ToGetValue} {FSingleton FunctionType} {The function stored on a function's
 \Slot (ToGetValue) is invoked when one requests \UnitSlot (x:S) .}>

\SlotEntry <{LispFnForSlot} {FSingleton FunctionType} {The value of \UnitSlot (S:LispFn
) is a function, which, when applied to a unit, \Unit (U) , returns the value of
 \UnitSlot (U:S) .}>

\SlotEntry <{AllSBF} {FSet SlotType} {This stands for All Slots Built From . It 
is used to hold the set of all slots which affect this one -- that is, \UnitSlot
 (x:S) \ may have to be invalidated if the \Slot (y) \ slot of some unit is changed,
 whenever y \EPSILON \UnitSlot (S:AllSBF) .}>
\SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Unioning SlotsBuiltFrom HandDoneSBF)>

\SlotEntry <{BeforeGetValue} {FSingleton FunctionType} {The value of \UnitSlot (
S:BeforeGetValue) is a function which is applied to a unit \Unit (U) \ and a \Slot
 (S) , and returns nonNIL if these arguments are appropriate.}>

\SlotEntry <{ActualGetValue} {FSingleton FunctionType} {The value of \UnitSlot (
S:ActualGetValue) is a function which is applied to a unit \Unit (U) \ and a \Slot
 (S) , and returns acutally does the retrieval of the vaue of \UnitSlot (U:S) .}>

\ClassEntry <{ Any$SELF$Slot }  35  {Descendants of this are the oft-spoken syntactic
 slots. That is, they each refer to this unit, {\it qua} unit, rather than what 
this unit represents. See \Unit (AnyCT&U) \ and \Unit (AnyAT&U) \ to understand 
this hackery.}>
\CFact SuperClass@AnyUnitFunction>
\hmode{\qquad There are currently 9 examples.}\par
\SlotsFor {$SELF$Slot}

\SlotEntry <{StoredInTypAs} {FSingleton SlotType} {This points to slot which holds
 the inheritable value in typical example units.}>
\SFact Inverse@StandsForSlot>

\ClassEntry <{ AnySlot }  36  {Every function which takes a unit as an argument,
 and which MAY BE STORED ON THAT UNIT, is a slot; and descends from \Unit (AnySlot
) .}>
\CFact SuperClass@AnyUnitFunction>
\CFact SubClass@AnyComputableSlot AnyField AnyInheritableSlot AnyPrimitiveSlot>
\SlotsFor {Slot}

\SlotEntry <{ComputeWhenFilled} {FSet SlotType} {Whenever a new value fills \UnitSlot
 (U:S) , the value of \UnitSlot (S:T) \ should be recomputed for each T \EPSILON
 \UnitSlot
 (S:ComputeWhenFilled) .}>

\SlotEntry <{IsEssentialFor} {FSet UnitType} {Some virtual slots must be stored 
on a unit for bootstrapping reasons. \UnitSlot (S:IsEssentialFor) \ holds a list
 of units which require this \Slot (S) \ slot.}>
\SFact Inverse@MyEssentialVirtualSlots>

\SlotEntry <{Inverse} {FSingleton SlotType} {Stating \Unit (S) \ is the \Slot (Inverse
) \ of a \Slot (T) \ means \Unit (x) \EPSILON \UnitSlot (y:S) \ iff \Unit (y) \EPSILON
 \UnitSlot (x:T) . The \EPSILON \ relation means \Unit (a) \EQUAL \Unit (b) \ if
 \Unit (b) \ is a singleton, otherwise a is in the list, b.}>
\SFact Inverse@Inverse>

\SlotEntry <{SuperSlot} {FSet SlotType} {Stating \Unit (SS) \ is a \Slot (SuperSlot
) \ of \Slot (S) \ means the value of \UnitSlot (x:S) \ will be a subset of the 
value of \UnitSlot (x:SS) , for all \Unit (x) \ in their common range.}>
\SFact Inverse@SubSlot>

\SlotEntry <{SubSlot} {FSet UnitType} {This is the inverse of \Slot (SuperSlot) 
.}>
\SFact Inverse@SuperSlot>

\SlotEntry <{MakesSenseFor} {FSet (UnitType (*P AnyArchetype))} {A given slot, \Unit
 (S) , may only be defined for certain particular units. \UnitSlot (S:MakesSenseFor
) \ points to a list of typical-example units. This \Slot (S) \ slot makes sense
 for each instance of each such unit.}>
\SFact Inverse@NewPossibleSlots>

\SlotEntry <{ToPutValue} {FSingleton FunctionType} {The function stored on \UnitSlot
 (S:ToPutValue) \ is called whenever putting a new value onto \UnitSlot (U:S) .}>

\SlotEntry <{ToInitialize} {FSingleton FunctionType} {When creating a new unit, 
all of the existing inheritance mechanisms first gather a collection of slots, which
 are meaningful to this new unit. Each slot, \Unit (S) , is then asked for its \UnitSlot
 (S:ToInitialize) \ function, which is then run. It is the responsibility of this
 function to actually store an appropriate value on this new unit.}>

\SlotEntry <{SuperSlot*} {FSet UnitType} {A list of a unit's SuperSlot, THEIR SuperSlot,
 etc.}>
\SFact Inverse@SubSlot*>
\SFact HighLevelDefn@(Starring SuperSlot)>

\SlotEntry <{SubSlot*} {FSet UnitType} {A list of a unit's SubSlot, THEIR SubSlot,
 etc.}>
\SFact Inverse@SuperSlot*>
\SFact HighLevelDefn@(Starring SubSlot)>

\SlotEntry <{ToAddValue} {FSingleton FunctionType} {Whenever one wishes to add one
 a value to the current value of \UnitSlot (U:S) , the function stored on \UnitSlot
 (S:ToAddValue) \ is called.}>

\SlotEntry <{ToDeleteValue} {FSingleton FunctionType} {Whenever one wants to delete
 a value from the list of values stored on \UnitSlot (U:S) , the function stored
 on \UnitSlot (S:ToDeleteValue) \ is called.}>

\SlotEntry <{ToSubstValue} {FSingleton FunctionType} {Whenever one wants to substitute
 one value for another, on the list of values stored on \UnitSlot (U:S) , the function
 stored on \UnitSlot (S:ToSubstValue) \ is called.}>

\SlotEntry <{KBUpdates} {FSingleton FunctionType} {Whenever a value is stored in
 a slot, various changed must be made throughout the Knowledge Bases, for truth 
maintanence reasons. A function designed to perform such modifications is stored
 in the \Slot (KBUpdates) \ slot of each slot. \UnitSlot (S:KBUpdates) \ is called
 whenever the value of \UnitSlot (x:S) \ is changed. \par This \Slot (KBUpdates)
 \ is calculated using the \Unit (FnForUpdating) \ slots of the various Slot Combiners
 used to define this \Unit (S) \ slot.}>

\SlotEntry <{VerifyAll} {FSingleton FunctionType} {Before accepting a value for 
storage on \UnitSlot (U:S) , it is tested for acceptability. This is done by calling
 \UnitSlot (S:VerifyAll) \ on this proposed value.}>

\SlotEntry <{VerifyElement} {FSingleton FunctionType} {When adding a new value to
 a slot's existing value, or substituting one value for another, it is often costly,
 and unnecessary, to check all of the values for acceptability. To verify the validity
 of one value, the function stored on \UnitSlot (S:VerifyElement) \ is called on
 that proposed new element.}>

\SlotEntry <{OrderForToInit} {FSingleton IntegerType} {Each slot will have a value,
 stored here, which indicates at what time its ToInitialize function should be invoked
 when a new unit is being created. It may use the global variables: uParent, uInheritance,
 and uAllInheritantedSlots, to make its decision.}>

\SlotEntry <{ActualPutValue} {FSingleton FunctionType} {The value of \UnitSlot (
S:ActualPutValue) \ is a function which is applied to a unit \Unit (U) , a \Slot
 (S) , and a value V, actually stores V on \UnitSlot (U:S) .}>

\SlotEntry <{ActualAddValue} {FSingleton FunctionType} {The value of \UnitSlot (
S:ActualAddValue) is a function which is applied to a unit \Unit (U) \ a \Slot (
S) , and a value V, and returns actually does the addition of the value V to the
 \UnitSlot (U:S) .}>

\SlotEntry <{ActualDeleteValue} {FSingleton FunctionType} {The value of \UnitSlot
 (S:ActualDeleteValue) is a function which is applied to a unit \Unit (U) \ a \Slot
 (S) , and a value V, and returns actually does the deletion of the value V from
 the \UnitSlot (U:S) .}>

\SlotEntry <{ActualSubstValue} {FSingleton FunctionType} {The value of \UnitSlot
 (S:ActualSubstValue) is a function which is applied to a unit \Unit (U) \ a \Slot
 (S) , and values V and W, and returns actually does the substitution of the value
 W for the value V in the \UnitSlot (U:S) .}>

\ClassEntry <{ AnyComputableSlot }  37  {These slots are redundant, as they could
 have been computed from other, more basic slots. (Modulo Garden-Of-Eden conditions.
 See \Unit (MyEssentialVirtualSlots) .)}>
\CFact SuperClass@AnySlot>
\hmode{\qquad There are currently 72 examples.}\par

\ClassEntry <{ AnyField }  38  {Slots on sub-units (that is, units devoted to storing
 the value of a slot of a given unit,) are called fields. Those ``slots'' which 
appear only in this context are stored under \Unit (AnyField) .}>
\CFact SuperClass@AnySlot>
\CFact Direct Examples@*vaLue* LivesInLocation LivesInSlot LivesInUnit>

\ClassEntry <{ AnyInheritableSlot }  39  {Descendants of this class are slots whose
 value may be inherited from some prototype of the unit in question. Or course, 
if there is a value stored on that unit, that value will be used.}>
\CFact SuperClass@AnySlot>
\CFact SubClass@AnyAccessSlot AnyFormatFnSlot>
\CFact Direct Examples@ToLookUp ToConfirmValue OrderForToInit>

\ClassEntry <{ AnyAccessSlot }  40  {Descendant of this \Unit (AnyAccessSlot) \ 
are slots used to manipulate the units themselves. For efficiency, they all use 
the same fast retrieval mechanism to determine their respective values -- \LispFn
 (GetAccessFn) .}>
\CFact SuperClass@AnyInheritableSlot>
\CFact Direct Examples@ToInvalidate ActualSubstValue ActualDeleteValue ActualAddValue
 ActualGetValue ActualPutValue ToGetValue BeforeGetValue AfterGetValue ToPutValue
 BeforePutValue AfterPutValue ToAddValue ToDeleteValue ToSubstValue ToInitialize
 MyToKillMe ToCacheField ToCache ToKillValue MyToRenameMe>

\ClassEntry <{ AnyFormatFnSlot }  41  {Various bits of information are associated
 with each format. When this information is functional, it descends from this \Unit
 (AnyFormatFnSlot) .}>
\CFact SuperClass@AnyInheritableSlot>
\hmode{\qquad There are currently 8 examples.}\par

\ClassEntry <{ AnyPrimitiveSlot }  42  {Primitive slots, which descend from this
 \Unit (AnyPrimitiveSlot) , cannot be computed if omitted. (As opposed to computable
 slots, which are technically redundant information, as they can be computed from
 more basic slots.)}>
\CFact SuperClass@AnySlot>
\CFact SubClass@AnySlot-Instances>
\hmode{\qquad There are currently 96 examples.}\par

\ClassEntry <{ AnySlot-Instances }  43  {Aliases used for syntactic slots are stored
 under \Unit (AnySlot-Instances) . These are used to hold values which should be
 inherited from typical example units; freeing the basic slot to hold the value 
pertanent to this particular unit.}>
\CFact SuperClass@AnyPrimitiveSlot>
\CFact Direct Examples@SlotsNowOrdered-Instances EssentialVirtualSlots-Instances
 ToKillMe-Instances ToRenameMe-Instances>
\SlotsFor {Slot-Instances}

\SlotEntry <{StandsForSlot} {FSingleton SlotType} {This points to the name of the
 syntactic slot for which this is an alias.}>
\SFact Inverse@StoredInTypAs>

\ClassEntry <{ AnyUnitListProcess }  44  {These processes take one or more units
 (amoung possibly other things) are arguments.}>
\CFact SuperClass@AnyProcess>
\CFact SubClass@AnyUnitProcess>

\ClassEntry <{ AnyUnitProcess }  45  {These processes take a single unit as its 
argument.}>
\CFact SuperClass@AnyUnitListProcess>
\CFact Direct Examples@EditUnit>

\ClassEntry <{ AnyUnit }  46  {Examples will be things which REPRESENT units... 
NOTE: this does NOT include every unit automatically! (In fact, most units represent
 some real world object, such as Tree$\#$32, or some conceptual entity, such as 
Red, or Function$\#$412.)}>
\CFact SuperClass@Anything>
\SlotsFor {Unit}

\SlotEntry <{MyCreatedAs} {FListN (UnitType (*P AnyInheritance)) (FList UnitType
)} {This stores inheritance information about this unit -- indicating, for example,
 that it was created as an \Unit (IExamples) \ (read ``Example'') of \Unit (AnySlot
) .}>

\SlotEntry <{MyEssentialVirtualSlots} {FSet SlotType} {These slots are essential
 for the Garden of Eden RLL system. Therefore \LispFn (RemoveVirtualSlots) \ is 
smart enough to know NOT to remove these slots (i.e. those which \Slot (MyEssentialVirtualSlots
) \ points to) from a unit.}>
\SFact Inverse@IsEssentialFor>

\SlotEntry <{MyTimeOfCreation} {FSingleton StringType} {This records when this unit
 was created.}>

\SlotEntry <{MyCreator} {FSingleton StringType} {This names the user who created
 this unit.}>

\SlotEntry <{MyToKillMe} {FSingleton FunctionType} {This function is called when
 deleting this unit.}>

\SlotEntry <{MySlotsNowOrdered} {FSet SlotType} {This lists the names of slots which
 are currently in the correct order. (For example, \Slot (OrderedPrototypes) \ appears
 in some unit's \Slot (MyEssentialVirtualSlots) \ only when the typical example 
units stored in \Slot (Prototypes) \ have been arranged in the correct order.)}>

\SlotEntry <{MySensibleSlots} {FSet SlotType} {Only certain slots are defined for
 a given unit. This list is stored in that unit's \Slot (MySensibleSlots) .}>
\SFact HighLevelDefn@(Composition NewPossibleSlots Prototypes)>

\SlotEntry <{MySlots} {FSet SlotType} {This never cached slot returns the list of
 slots belonging to this unit.}>
\SFact Inverse@AmUsedIn>

\SlotEntry <{MyToRenameMe} {FSingleton FunctionType} {This function is called when
 renaming this unit to another name.}>

\ClassEntry <{ AnyUser }  47  {RLL tries to hold some primitive information about
 each user of this system. A unit is devoted to each user, (as well as each recognized
 user class) ; and this information is under \Unit (AnyUser) .}>
\CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyHacker>
\CFact Direct Examples@AndyFreeman LarryHines>
\SlotsFor {User}

\SlotEntry <{InformalName} {FSingleton StringType} {This is a name RLL can use to
 greet this user.}>

\SlotEntry <{UsualKBs} {FSet KBType} {These are the Knowledge Bases this user usually
 wants loaded in.}>

\SlotEntry <{WritingOptions} {FList NonNILType} {When closing a Knowledge Base, 
RLL must ask the user several questions. To sidestep this tedious (and often unneccessary
) process, the user can indicate a fixed set of responses to such inquires; which
 are stored on this \Slot (WritingOptions) \ slot. When closing the KBs, the user
 is now asked a single question -- if he wishes to use these. (Answering No forces
 RLL to ask him these questions one by one.) \par The defaulted writing function,
 \LispFn (StandardFinishUp) , asks if virtual slots should be removed, if this KB
 should be disconnected from the others, and if this KB should be diagnosed; in 
that order. Setting \Slot (WritingOptions) \ to (Y N Y) instructs RLL to remove 
virtual slots, and diagnose the KB, but not to disconnect it.}>

\SlotEntry <{OpenningOptions} {FList UnrestrictedType} {Like \Slot (WritingOptions
) , this helps the user to avoid a potentially dull task. The value stored here 
will be handed to the function called when openning each knowledge base; if the 
user indicates he wishes his default setting to be used. \par The only question 
\LispFn (StandardStartUp) \ might ask is whethr to reconnect an enterring knowledge
 base. Setting the \Slot (OpenningOptions) \ slot to (NIL) means this question will
 be asked each time.}>

\SlotEntry <{UserNames} {FSet StringType} {This lists the system names this user
 may go by. (Ie values of \LispFn ({ (USERNAME) }) \ which correspond to this person.
)}>

\ClassEntry <{ AnyHacker }  48  {This class includes people working on RLL.}>
\CFact SuperClass@AnyUser>
\CFact Direct Examples@DougLenat RussGreiner>

\ClassEntry <{ AnyConcreteThing }  49  {Instances refer to tangible objects, (such
 as trees,) as opposed to abstract things (such as variables) .}>
\CFact SuperClass@Anything>

\StartIndex
\IS <*vaLue* 38,6>
\IS <ActualAddValue 40,36>
\IS <ActualDeleteValue 40,36>
\IS <ActualGetValue 40,34>
\IS <ActualPutValue 40,36>
\IS <ActualSubstValue 40,36>
\IS <AfterGetValue 40,34>
\IE <AfterPutValue 40>
\IS <AllExamples 17>
\IS <AllGenls 1>
\IS <AllIsas 1>
\IS <AllSBF 34>
\IS <AllSpecs 1>
\IE <AndyFreeman 47>
\IU <Any$SELF$Slot 35>
\IU <AnyAT&U 2>
\IU <AnyAbstractThing 9>
\IU <AnyAccessSlot 40>
\IU <AnyAction 24>
\IU <AnyActionSequence 19>
\IU <AnyArchetype 4>
\IU <AnyCT&U 10>
\IU <AnyCharacteristic 11>
\IU <AnyClassOfObjects 17,1>
\IU <AnyComputableSlot 37>
\IU <AnyConcreteThing 49>
\IU <AnyDatatype 12>
\IU <AnyDecomposableObject 18>
\IU <AnyDescriptor 5>
\IU <AnyField 38>
\IU <AnyFormat 13>
\IU <AnyFormatFnSlot 41>
\IU <AnyFunction 25>
\IU <AnyFunctional 26>
\IU <AnyHacker 48>
\IU <AnyIndirectPtrFormat 16>
\IU <AnyInheritableSlot 39>
\IU <AnyInheritance 20>
\IU <AnyIntensionalObject 3>
\IU <AnyLogicalOp 27>
\IU <AnyOverhead 21>
\IU <AnyPartialSpec 8>
\IU <AnyPredicate 29>
\IU <AnyPrimitiveSlot 42>
\IU <AnyProcess 23>
\IU <AnySlot 36>
\IU <AnySlot-Instances 43>
\IU <AnySlotCombiner 28>
\IU <AnySlotFormat 14>
\IU <AnySlotGetter 32>
\IU <AnySlotListFn 33>
\IU <AnyStatus 22>
\IU <AnyStorableFn 30>
\IU <AnyUnit 46>
\IU <AnyUnitForSlot 6>
\IU <AnyUnitFunction 34>
\IU <AnyUnitListFn 31>
\IU <AnyUnitListProcess 44>
\IU <AnyUnitProcess 45>
\IU <AnyUser 47>
\IU <AnyValueFormat 15>
\IU <AnyVariable 7>
\IU <Anything 1>
\IE <Application 28>
\IE <Apply*ingFn 26>
\IE <ApplyToEach 26>
\IE <ApplyingFn 26>
\IS <BeforeGetValue 40,34>
\IE <BeforePutValue 40>
\IE <BooleanType 12>
\IS <CVUsedBy 23>
\IS <Characteristics 1>
\IS <CombinerFor 26>
\IE <CommonXProd 28>
\IS <ComposedOf 18>
\IE <Composition 28>
\IS <ComputeWhenFilled 36>
\IS <DataRange 25>
\IS <Datatype 25>
\IS <Definition 25>
\IS <Defn 25>
\IS <DefnUsedBy 23>
\IS <DependentNetworks 22>
\IS <Descr 1>
\IE <DescribeUnit 24>
\IS <Domain 25>
\IS <DomainOf 17>
\IS <DomainType 25>
\IE <DoneIndirectly 28>
\IE <DougLenat 48>
\IE <EditUnit 45>
\IS <EqualDTSpec 12>
\IE <EssentialVirtualSlots-Instances 43>
\IE <FBag 14>
\IE <FExecute 15>
\IE <FList 14>
\IE <FListN 14>
\IE <FOneOf 15>
\IE <FOrderedSet 14>
\IE <FSeeSlot 16>
\IE <FSeeU&S 16>
\IE <FSeeUnit 16>
\IE <FSet 14>
\IE <FSingleton 14>
\IE <FirstOk 28>
\IS <FnForAdding 13>
\IS <FnForCaching 28>
\IS <FnForDeleting 13>
\IS <FnForGetting 13>
\IS <FnForInverting 28>
\IS <FnForKilling 13>
\IS <FnForPutting 13>
\IS <FnForUpdating 28>
\IS <FnForVerifyingAll 13>
\IS <FnForVerifyingElement 13>
\IS <Format 25>
\IS <FormatCharacter 13>
\IS <FunctionCharacter 25>
\IE <FunctionSpec 34>
\IE <FunctionType 12>
\IS <GenerateAll 12>
\IS <GenlAct 24>
\IS <GenlAct* 24>
\IS <GenlsModels 17>
\IS <GetCVsUsed 26>
\IS <GetFnsUsed 26>
\IS <GetPossibleSlotsFn 20>
\IS <HandDoneSBF 34>
\IS <HighLevelDefn 25>
\IS <HowToProcess 23>
\IE <IExamples 20>
\IE <ISubClass 20>
\IE <ITypEx 20>
\IS <IUseCVOf 23>
\IS <IUseDefnOf 23>
\IS <InformalName 47>
\IE <IntegerType 12>
\IS <IntensionalExamples 17>
\IE <Intersecting 28>
\IS <Inverse 36>
\IS <IsBuiltFrom 25>
\IS <IsEssentialFor 36>
\IS <IsTypeOf 12>
\IS <Isa 1>
\IE <KBType 12>
\IS <KBUpdates 36>
\IS <KBsConnectedTo 22>
\IS <KBsFNS 22>
\IS <KBsFreeBlockIndex 22>
\IS <KBsUnitIndex 22>
\IS <KBsVARS 22>
\IE <L-NOT 27>
\IE <L-OR 27>
\IE <L-Optional 27>
\IE <LarryHines 47>
\IS <LispFn 23>
\IS <LispFnForSlot 34>
\IS <LispFnForStoredFn 30>
\IE <Listing 28>
\IE <LivesInLocation 38>
\IE <LivesInSlot 38>
\IE <LivesInUnit 38>
\IS <LoadFiles 22>
\IS <MakesSenseFor 36>
\IE <MemberOf 26>
\IS <MyCreatedAs 46>
\IS <MyCreator 46>
\IS <MyEssentialVirtualSlots 46>
\IE <MyKB 34>
\IS <MyRefineSlots 8>
\IS <MySensibleSlots 46>
\IS <MySlots 46>
\IS <MySlotsNowOrdered 46>
\IS <MyTimeOfCreation 46>
\IS <MyToKillMe 46,40>
\IS <MyToRenameMe 46,40>
\IS <NetworkStatus 22>
\IS <Networks 22>
\IS <NewPossibleSlots 4>
\IE <NonNILType 12>
\IE <NumberType 12>
\IE <OneOf 28>
\IS <OpenDate 22>
\IS <OpenningOptions 47>
\IS <OrderForToInit 39,36>
\IE <OrderedComposition 28>
\IS <OrderedPrototypes 1>
\IE <OrderedStarring 28>
\IE <OrderedUnioning 28>
\IE <Plussing 28>
\IS <PossibleSlots 4>
\IE <PossibleSlotsOfIExamples 32>
\IE <PossibleSlotsOfISubClass 32>
\IE <PossibleSlotsOfITypEx 32>
\IS <PreConditions 25>
\IS <Prototypes 1>
\IE <PutInOrder 28>
\IE <RLL.STATUS 22>
\IS <Range 25>
\IS <RangeInterpreter 12>
\IS <RangeOf 17>
\IS <RangeType 25>
\IE <RussGreiner 48>
\IE <SlotType 12>
\IS <SlotsBuiltFrom 25>
\IE <SlotsNowOrdered-Instances 43>
\IS <SlotsUsedInBuilding 25>
\IE <Soften 28>
\IS <SpecAct 24>
\IS <SpecAct* 24>
\IS <Specializations 1>
\IS <StandsForSlot 43>
\IE <Starring 28>
\IS <StdExamples 17>
\IS <StoredAList 30>
\IS <StoredInTypAs 35>
\IE <StringType 12>
\IS <SubActions 19>
\IS <SubClass 17>
\IS <SubClass* 17>
\IS <SubDT 12>
\IS <SubDT* 12>
\IS <SubSlot 36>
\IS <SubSlot* 36>
\IS <SubTypEx 4>
\IS <SubTypEx* 4>
\IE <Subsetting 28>
\IS <SuperClass 17>
\IS <SuperClass* 17>
\IS <SuperDT 12>
\IS <SuperDT* 12>
\IS <SuperSlot 36>
\IS <SuperSlot* 36>
\IS <SuperTypEx 4>
\IS <SuperTypEx* 4>
\IS <ToAddValue 40,36>
\IS <ToCache 40,30>
\IE <ToCacheField 40>
\IS <ToConfirmValue 39,30>
\IS <ToDeleteValue 40,36>
\IS <ToGetValue 40,34>
\IS <ToInitialize 40,36>
\IS <ToInvalidate 40,30>
\IE <ToKillMe-Instances 43>
\IE <ToKillValue 40>
\IS <ToLookUp 39,30>
\IS <ToParseParts 26>
\IS <ToPutValue 40,36>
\IE <ToRenameMe-Instances 43>
\IS <ToSubstValue 40,36>
\IS <TotalSoFar 17>
\IS <TypicalExample 17>
\IS <TypicalExampleOf 4>
\IE <Unioning 28>
\IS <UnitExamples 17>
\IE <UnitType 12>
\IS <UnitsBuiltFrom 25>
\IE <UnrestrictedType 12>
\IS <UseToGetSlots 20>
\IS <UserNames 47>
\IS <UsingFunctionals 25>
\IS <UsingFunctions 25>
\IS <UsingSlotCombiners 34>
\IS <UsualKBs 47>
\IS <VerifyAll 36>
\IS <VerifyArgs 23>
\IS <VerifyElement 36>
\IS <VerifyType 12>
\IS <WhatToProcess 23>
\IS <WhenOpeningNetwork 22>
\IS <WhenWritingNetwork 22>
\IS <WritingOptions 47>
\par\vfill\eject\end